import java.util.*;

public class Demo9 {


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.next();
        int b1 = 0;//全小写或全大写
        int b2 = 0;//大小写混合
        int c = 0;//数字
        int d = 0;//符号
        int len = str.length();
        int count = 0;

        //密码长度
        if (len<=4){
            count+=5;
        }else if(len>=5 && len<=7){
            count+=10;
        }else if(len>=8){
            count+=25;
        }

        //字母
        int little = 0;
        int big = 0;
        //数字
        int num = 0;
        //符号
        int chare = 0;
        for(int i = 0;i<len;i++){
            if (str.charAt(i)>='a' && str.charAt(i)<='z'){
                little++;
            }else if (str.charAt(i)>='A' && str.charAt(i)<='Z'){
                big++;
            }
            //数字
            if (str.charAt(i)>='0' && str.charAt(i)<='9'){
                num++;
            }
            //符号
            if ((str.charAt(i)>=0x21&&str.charAt(i)<=0x2F)
                    || (str.charAt(i)>=0x3A&&str.charAt(i)<=0x40)
                    || (str.charAt(i)>=0x5B&&str.charAt(i)<=0x60)
                    || (str.charAt(i)>=0x7B&&str.charAt(i)<=0x7E)){
                chare++;
            }

        }
        if (little+big==0){
        }else if(little==len || big==len){
            count+=10;
            b1++;
        }else if(little<len && big<len){
            count+=20;
            b2++;
        }
        //数字
        if (num==1){
            count+=10;
            c++;
        }else if(num>1){
            count+=20;
            c++;
        }

        //符号
        if (chare==1){
            count+=10;
            d++;
        }else if(chare>1){
            count+=25;
            d++;
        }
        if (b1==1 && b2==0 && c==1 && d==0){
            count+=2;
        }else if (b1==1 && b2==0 && c==1 && d==1){
            count+=3;
        }else if (b1==0 && b2==1 && c==1 && d==1){
            count+=5;
        }

        if (count>=90){
            System.out.println("VERY_SECURE");
        }else if(count>=80){
            System.out.println("SECURE");
        }else if (count>=70){
            System.out.println("VERY_STRONG");
        } else if (count>=60) {
            System.out.println("STRONG");
        }else if (count>=50){
            System.out.println("AVERAGE");
        } else if (count >= 25) {
            System.out.println("WEAK");
        }else {
            System.out.println("VERY_WEAK");
        }

    }


/*    public boolean checkWon(int[][] board) {

        for(int i = 0;i<3;i++){
            if (board[i][0]==board[i][1] && board[i][1]==board[i][2] && board[i][0]==1){
                return true;
            }
        }
        for(int i = 0;i<3;i++){
            if (board[0][i]==board[1][i] && board[1][i]==board[2][i] && board[0][1]==1){
                return true;
            }
        }
        if (board[0][0]==board[1][1] && board[1][1] == board[2][2] && board[1][1]==1){
            return true;
        }
        if (board[0][2]==board[1][1] && board[1][1] == board[2][0] && board[1][1]==1) {
            return true;
        }

        return false;
    }*/
















    /*public static void main(String[] args) {

    }


    public static int[][] count (String str) {
        HashMap<Character, Integer> hash = new HashMap<>();
        hash.put('@',1);
        hash.put('!',2);
        hash.put('.',3);
        hash.put('/',4);

        hash.put('a',1);
        hash.put('b',2);
        hash.put('c',3);

        hash.put('d',1);
        hash.put('e',2);
        hash.put('f',3);

        hash.put('g',1);
        hash.put('h',2);
        hash.put('i',3);

        hash.put('j',1);
        hash.put('k',2);
        hash.put('l',3);

        hash.put('m',1);
        hash.put('n',2);
        hash.put('o',3);

        hash.put('p',1);
        hash.put('q',2);
        hash.put('r',3);
        hash.put('s',4);

        hash.put('t',1);
        hash.put('u',2);
        hash.put('v',3);

        hash.put('w',1);
        hash.put('x',2);
        hash.put('y',3);
        hash.put('z',4);




    }



*/




/*    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int[][] vis = new int[m+1][n+1];

        for(int i = 0;i<=m;i++){
            for(int j=0;j<=n;j++){
                if (i==0||j==0){
                    vis[i][j]=1;
                }else{
                    vis[i][j]=vis[i-1][j]+vis[i][j-1];
                }
            }
        }
        System.out.println(vis[m][n]);


    }*/

/*
    public static void main(String[] args) {
        System.out.println(addAB(10,20)+"," +(10+20));
    }
    public static int addAB(int A, int B) {
        return (A^B)^((A&B)<<1);
    }
*/


   /* public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
       int a = in.nextInt();
       int b = in.nextInt();
       int ret = Math.max(a, b);
       while (true){
           if (ret%a==0&&ret%b==0){
               System.out.println(ret);
               break;
           }
           ret++;
       }
    }

*/
  /*  public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        List<String> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
        for(int i = 0;i<n;i++){
            String str = in.nextLine();
            list.add(str);
            list1.add(str);
        }

        //先判断是否按长度排序
        int flagLength = 1;
        for(int i =0;i<n-1;i++){
            if (list.get(i).length()>list.get(i+1).length()){
                flagLength = 0;
                break;
            }
        }
        //判断是否按照字典序排序
        list1.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        int flagDirect = 1;
        for(int i =0;i<n;i++){
            if (list.get(i).length()!=list1.get(i).length()){
                flagDirect = 0;
                break;
            }
        }

        if (flagLength==1 && flagDirect==1){
            System.out.println("both");
        }
        if (flagDirect==1 && flagLength==0){
            System.out.println("lexicographically");
        }
        if (flagDirect==0 && flagLength==1){
            System.out.println("lengths");
        }
        if (flagDirect==0 && flagLength==0){
            System.out.println("none");
        }



    }*/


//    public static void main(String[] args) {
      /*  Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = 0;
        int b = 1;
        int c = 1;
        while (c<n){
            a=b;
            b=c;
            c = a+b;
        }
        int ret = Math.min(c-n, n-b);
        System.out.println(ret);
*/



/*        System.out.println(chkParenthesis("(())())",7));


    }

    public static boolean chkParenthesis(String A, int n) {
        int count = 0;
        for(int i =0;i<n;i++){
            if (A.charAt(i) == '('){
                count++;
            }else if(A.charAt(i) == ')'){
                count--;
                if (count<0){
                    return false;
                }
            }
        }
        if (count==0){
            return true;
        }
        return false;
    }*/


    /*public int minOperations(String _s1, String _s2, int x) {
        char[] s1 = _s1.toCharArray();
        char[] s2 = _s2.toCharArray();

        int[] check = new int[s1.length];
        int count = 0;//表示一共反转的次数
        int left = 0;
        int right = 0;
        int vis = 0;//表示异或之后1的个数

        for(int i = 0;i<s1.length;i++){
            int a = s1[i]-'0';
            int b = s2[i]-'0';
            check[i] = a^b;
            if (check[i]%2==1){
                vis++;
            }
        }
        if (vis%2==1){
            return -1;
        }
        for(int i = 0;i<check.length;i++){
            right=i;
            if (check[i]==0){
                if (check[left]==0){
                    left++;
                }
            } else if (check[i]==1){
                if (right-left!=0 && right-left>x){
                    count+=x;
                    left=i+1;

                }else if(right-left!=0 && right-left <= x){
                    count+= (right-left);
                    left=i+1;

                }
            }

        }
        return count;


    }*/



/*    public int minProcessingTime(List<Integer> processorTime, List<Integer> tasks) {
        processorTime.sort(new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        tasks.sort(new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        int ret = 0;
        for(int i = 0;i<processorTime.size();i++){
            ret = Math.max(ret,processorTime.get(i)+tasks.get(i*4));
            ret = Math.max(ret,processorTime.get(i)+tasks.get(i*4+1));
            ret = Math.max(ret,processorTime.get(i)+tasks.get(i*4+2));
            ret = Math.max(ret,processorTime.get(i)+tasks.get(i*4+3));
        }
        return ret;



    }*/

/*    public int differenceOfSums(int n, int m) {
        int num1 = 0;
        int num2 = 0;
        for(int i = 1;i<=n;i++){
            if (i%m!=0){
                num1+=i;
            }
            if (i%m==0){
                num2+=i;
            }
        }
        return num1-num2;


    }*/




    /*int dx[] = {0,0,1,-1};
    int dy[] = {1,-1,0,0};
    int m,n;
    int count;
    int ret;
    int[][] memo;
    public int longestIncreasingPath(int[][] matrix) {
        m = matrix.length;
        n = matrix[0].length;
        memo = new int[m][n];

        for(int i = 0;i<m;i++){
            for(int j = 0;j<n;j++){
                count = 0;
                memo = new int[m][n];
                dfs(i,j,matrix);
                ret = Math.max(ret,count);
            }
        }
        return ret;
    }

    private void dfs(int i, int j,int[][] matrix) {
        if (memo[i][j]==0){
            memo[i][j] = 1;
            count++;
        }

        for(int k=0;k<4;k++){
            int x = i+dx[k];
            int y = j+dy[k];
            if (x>=0&&x<m&&y>=0&&y<n&&memo[x][y]==0&&matrix[x][y]>matrix[i][j]){
                dfs(x,y,matrix);
                count--;
            }
        }
    }

*/



/*    public int uniquePaths(int m, int n) {
        int[][] memo = new int[m+1][n+1];
        memo[0][1]=1;
        for(int i = 1;i<=m;i++){
            for(int j = 1; j <= n; j++){
                memo[i][j] = memo[i-1][j] + memo[i][j-1];
            }
        }
        return memo[m][n];

    }*/



/*    public int numDecodings(String ss) {
        //1.创建dp表
        int n = ss.length();
        char[] s = ss.toCharArray();
        int[] dp = new int[n];
        //2.初始化
        if (s[0]!='0')dp[0] = 1;

        if (n==1){
            return dp[0];
        }

        if(s[1]!='0' && s[0]!='0') dp[1]+=1;
        int t = (s[0]-'0')*10 + (s[1]-'0');
        if (t>=10 && t<=26){
            dp[1]++;
        }
        //3.填表
        for(int i = 2;i<n;i++){
            //先处理第一种情况
            if (s[i]!='0')dp[i]+=dp[i-1];

            //第二种情况
            int tt = (s[i-1]-'0')*10 + (s[i]-'0');
            if (tt>=10 && tt<=26){
                dp[i] += dp[i-2];
            }

        }


        return dp[n-1];

    }*/










/*    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length+1];
        if (cost.length==1){
            return cost[0];
        }
        if (cost.length == 2){
            return Math.min(cost[0],cost[1]);
        }

        dp[0] = 0;
        dp[1] = 0;

        for(int i = 2;i<=cost.length;i++){
            dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[cost.length];

    }*/








/*    public int waysToStep(int n) {
        if (n==1){
            return 1;
        }
        if (n==2){
            return 2;
        }
        if (n==3){
            return 4;
        }
        int a=1,b=2,c=4,d=0;
        for(int i = 4;i<=n;i++){
            d = ((a+b)%1000000007+c)%1000000007;
            a=b;
            b=c;
            c=d;
        }
        return d;
    }*/






/*    public int tribonacci(int n) {
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;
        if (n==0){
            return 0;
        }
        if (n==1||n==2){
            return 1;
        }

        for(int i = 3;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2]+dp[i-3];
        }
        return dp[n];

    }*/



}
